﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Text.RegularExpressions;

using Ivy.Common.Framework.GeneralUtility;

using Ivy.UserManagement.Entity;
using Ivy.UserManagement.BusinessLogic;

using Ivy.SiteAdministration.Entity;
using Ivy.SiteAdministration.BusinessLogic;

using Ivy.SiteGeneralBasic.Entity;
using Ivy.SiteGeneralBasic.BusinessLogic;

using SEPAIWebsite.App_Code;
namespace SEPAIWebsite.UserControls
{
    public partial class User_Role_AllocationDetailsControl : System.Web.UI.UserControl
    {
        #region  Variable & constant
        // All constants and local variable should be declared here
        // TRY NOT TO CREATE PUBLIC VARIABLES INSTEAD USE PROPERTIES FOR THAT PURPOSE.
        // Variable naming convention :- 
        // The naming should be self explanatory, make it long to explain the purpose 
        // and use PascalCase to seperate words as shown in the example below.
        // DO NOT USE ANY ABBRIVIATION use full word (like "Customer" instead of "Cust"
        // Naming convention for all local variable should start with underscore "_"
        // Naming convention for all local constant should start with "_The"
        // Example :    string _CustomerCode = string.Empty;
        // Example :    const string _TheDefaultSmtpServer = "DefaultSmtpServer";
        // ==================== START YOUR CODE FROM NEXT LINE ========================

        //Needed for Authorization logic.
        //For Screens that can be accessed by any users, even guest users, the default Page level IsAnonymousAccess value will be TRUE.
        //But for Screens with access restriction the IsAnonymousAccess value will be FALSE.
        const string _TheDefaultUserContextSessionVariableName = "UserContext";
        const string _TheDefaultValueForUserRoleAllocationSessionVariableName = "UserRoleAllocationSession";
        bool IsAnonymousAccess = true;

        //Needed for Authorization logic.
        //For Screens that are Non-Organization specific related (Generic) Activities, the default Page level IsNonOrganizationSpecificActivity value will be TRUE.
        //But for Screens with Activities related to Organization the IsNonOrganizationSpecificActivity value will be FALSE.
        bool IsNonOrganizationSpecificActivity = true;

        //Needed for Authorization logic.
        //For Screens with multiple activities, the default ActivityCode value will be [string.Empty], it will be initialized dynamically with query string from the calling event.
        //But for single ActivityCode like only view for reports or only insert etc. we need to assign the specific value below.
        //And for any Screen which only for display by any registered user the ActivityCode value will be [SystemActivities.RetrieveBlogs]
        //Please ensure to make an entry into the App_Code -> ApplicationKeyWords.cs file under the class SystemActivities with respective ActivityCode.
        string _CurrentActivityCode = "CREATE_USERROLEALLOT";

        //Needed for Screen initialization logic.
        //For Screens with multiple ScreenActionMode, the default value will be [ScreenActionMode.UnKnown], it will be initialized dynamically with query string from the calling event.
        //but for single ScreenActionMode like only view for reports or only insert etc. we need to assign the specific value below.
        ScreenActionMode _CurrentScreenActionMode = ScreenActionMode.Edit;

        #endregion  Variable & constant

        #region Constructor & Destructor
        // Generally not needed in UI layer.
        // Cut and Copy the default constructor for the class inside this region.
        // Generally not required in UI layer.
        // Example:
        // public SampleClassTemplate()
        // {

        // }
        // ==================== START YOUR CODE FROM NEXT LINE ========================
        //public SampleAspxUIClassTemplate()
        //{
        //}

        #endregion Constructor & Destructor

        #region Properties
        // Any value/variable that needs to be exposed outside the class we need to create a property.
        // Avoid creating public variables rather create public properties.
        // UI layer may have public custom properties. these are very handy for User Controls.
        // Property naming convention :- Properties will be exposed outside the class, 
        // the naming should be self explanatory, make it long to explain the purpose 
        // and use PascalCase to seperate words as shown in the example below.
        // DO NOT USE ANY ABBRIVIATION use full word (like "Customer" instead of "Cust"
        // All properties should have a corresponding local variable 
        // and the property name and local variable name should match.
        // Example :
        // public string CustomerCode
        // {
        //     get
        //     {
        //         return _CustomerCode;
        //     }
        //     set
        //     {
        //         _CustomerCode = value;
        //     }
        // }
        // ==================== START YOUR CODE FROM NEXT LINE ========================


        #endregion Properties

        #region Events
        // Generally UI layer will have public events.
        // Cut and Copy the default generated events for the class inside this region.
        // ==================== START YOUR CODE FROM NEXT LINE ========================

        protected void Page_Load(object sender, EventArgs e)
        {
            try //All events in pages or user control should have try{} catch {} block.
            {
                if (!Page.IsPostBack)
                {
                    //First check if the current logged in user is having proper role/authorization to access this page or not.
                    if (IsUserAutherization())
                    {
                        //TODO - Your code to display the initial layout/data etc.
                        InitializeScreen();
                    }
                    else
                    {
                        //TODO - Your code to redirect page to "NOT AUTHORIZED" page or any other page as required by the business logic.
                        //Response.Redirect("../BasicPages/UnAuthorizedGuest.aspx");
                        //Response.Redirect("../BasicPages/UnAuthorizedMember.aspx");
                    }
                }
            }
            catch (Exception ex)
            {
                UIExceptionUtility.ExceptionHandler(ex, Server.MapPath("~/"));
            }
        }
        protected void btnAddSelectedActivites_Click(object sender, EventArgs e)
        {

            if (ViewState[_TheDefaultValueForUserRoleAllocationSessionVariableName] != null)
            {
                //Retrieving Sys_RoleMaster from seesson variable.
                UserRoleAllocationHeaderReport _UserRoleAllocationHeaderReport = (UserRoleAllocationHeaderReport)ViewState[_TheDefaultValueForUserRoleAllocationSessionVariableName];

                foreach (GridViewRow gvrow in this.gvAddUserRoleAllocationDetails.Rows)
                {
                    CheckBox chk = (CheckBox)gvrow.FindControl("chkCtrl");

                    //Checking is there any checkbox selected or not.
                    if (chk != null & chk.Checked)
                    {
                        //Fetching ActivityKey from selected gridview row.
                        int RoleKey = Convert.ToInt32(gvAddUserRoleAllocationDetails.DataKeys[gvrow.RowIndex].Value);
                        SiteAdministrationBus _SiteAdministrationBus = new SiteAdministrationBus();
                        //Retrieving selected record from Sys_ActivityMaster table.
                        UserManagementBus _UserManagementBus = new UserManagementBus();
                        UserOrganizationRole _UserOrganizationRole = new UserOrganizationRole();

                        Sys_RoleMaster _Sys_RoleMaster = _SiteAdministrationBus.GetSys_RoleMasterByKey(RoleKey);
                        if (_Sys_RoleMaster != null)
                        {
                            TranslateUserRoleAllocationUIControlsToEntity(_Sys_RoleMaster, _UserOrganizationRole, _UserRoleAllocationHeaderReport);

                            //Inserting seleted record to Sys_RoleActivityMaster table.
                            _UserManagementBus.AddUserOrganizationRole(_UserOrganizationRole);
                            this.lblMessage.InnerHtml = "Added selected activity to this role.";
                            UserRoleAllocationDetailsModalPopupExtender.Show();
                        }
                    }
                    //if (chk.Checked == true)
                    //{
                    //    chk.Checked = false;
                    //}
                }


            }
        }
        protected void chkAddUserRoleAllocationDetails_CheckedChanged(object sender, EventArgs e)
        {
            if (chkAddUserRoleAllocationDetails.Checked == true)
            {
                chkAddUserRoleAllocationDetails.Checked = true;
                //LoadAllActivityMasterDetails();
                this.DivAddUserRoleAllocationDetails.Visible = true;
            }
            else
            {
                chkAddUserRoleAllocationDetails.Checked = false;
                this.DivAddUserRoleAllocationDetails.Visible = false;
            }
        }
        protected void gvAddUserRoleAllocationDetails_OnPageIndexChanging(object sender, GridViewPageEventArgs e)
        {
            this.gvAddUserRoleAllocationDetails.PageIndex = e.NewPageIndex;
            gvAddUserRoleAllocationDetails.DataBind();
        }

        protected void gvRemoveActivityDetails_OnPageIndexChanging(object sender, GridViewPageEventArgs e)
        {
            this.gvRemoveUserRoleAllocationDetails.PageIndex = e.NewPageIndex;
            gvRemoveUserRoleAllocationDetails.DataBind();
        }

        protected void btnRoleActivitySuccessOk_Click(object sender, EventArgs e)
        {
            UserRoleAllocationDetailsModalPopupExtender.Hide();
            InitializeScreen();
        }
        #endregion Events

        #region Public Methods
        // UI layer may have public custom Methods. These are very handy for User Controls.
        // Any method that needs to be exposed outside the class will be created inside this region.
        // Public Method naming convention :- Public Method will be exposed outside the class, 
        // The input and output parameters are also going to be exposed outside the class
        // the naming should be self explanatory, make it long to explain the purpose 
        // and use PascalCase to seperate words as shown in the example below.
        // DO NOT USE ANY ABBRIVIATION use full word (like "Customer" instead of "Cust"
        // Example :
        // public bool RegisterNewCustomer(Customer Customer)
        // {
        //     bool IsCustomerDataSaved = false;
        //     //TO DO logic to save data
        //     IsCustomerDataSaved = InsertCustomerDataUsingDao(Customer);
        //     return IsCustomerDataSaved;
        // }
        // ==================== START YOUR CODE FROM NEXT LINE ========================


        #endregion Public Methods

        #region Private Methods
        // All local class level methods will be inside this region. Mostly these are helper methods.
        // Private Method naming convention :- The naming should be self explanatory, 
        // make it long to explain the purpose and use PascalCase to seperate words as shown in the example below.
        // DO NOT USE ANY ABBRIVIATION use full word (like "Customer" instead of "Cust"
        // Input parameter will have a "p" as prefix. 
        // This will help the parameter variable that the value is originated outside this private method.
        // Example :
        // public bool InsertCustomerDataUsingDao(Customer pCustomer)
        // {
        //     bool IsCustomerDataInsertedSuccessfully = false;
        //     //TO DO logic to save data
        //     //....
        //     //....
        //     return IsCustomerDataInsertedSuccessfully;
        // }
        // ==================== START YOUR CODE FROM NEXT LINE ========================


        /// <summary>
        /// This method is to check if the current logged in user is having proper role/authorization to access this page or not.
        /// </summary>
        private bool IsUserAutherization()
        {
            bool _IsUserAutherization = false;
            //TODO - Your code to check authorization goes here.


            //Check if the Screen has Access Restriction.
            if (IsAnonymousAccess)
            {
                _IsUserAutherization = true; //by default the activity can be executed by any person even guest user.
            }
            else
            {
                User _User = SessionUtility.GetCurrentLoginUser();
                if (_User != null)
                {
                    ////Check if the Screen Activity is a Non-Organization specific activity then the  _UserDefaultOrzanization code will be -1 (SYSTEM)
                    Sys_OrganizationMaster _UserDefaultOrzanization;
                    _UserDefaultOrzanization = SessionUtility.GetCurrentLoginUserOrzanization();
                    UserManagementBus _UserManagementBus = new UserManagementBus();

                    //if (IsNonOrganizationSpecificActivity)
                    //{
                    //    SiteAdministrationBus _SiteAdministrationBus = new SiteAdministrationBus();
                    //    //Set _UserDefaultOrzanization = System/-1
                    //    _UserDefaultOrzanization = _SiteAdministrationBus.GetSys_OrganizationMasterByKey(-1);
                    //}

                    if (_UserDefaultOrzanization != null)
                    {
                        //Check if QueryString for ActivityCode is supplied, then this Screen is for multiple Activities 
                        //and the current instance ActivityCode is supplied by the QueryString. 
                        //In that case we need to overwrite the default ActivityCode from string.Empty to the QueryString value.
                        if (!string.IsNullOrEmpty(Request.QueryString["ActivityCode"]))
                        {
                            _CurrentActivityCode = Request.QueryString["ActivityCode"].ToString();
                        }
                        //Get the Authorization details for the current logged in user and the the role
                        _IsUserAutherization = _UserManagementBus.IsAcitivityAuthorized(_UserDefaultOrzanization.OrganizationCode, _CurrentActivityCode, _User.UserLoginId);
                    }
                }
            }
            return _IsUserAutherization;
        }

        /// <summary>
        /// This method is to clear all UI controls which are data binded.
        /// </summary>
        private void ClearScreen()
        {
        }

        /// <summary>
        /// This method is to bind all the UI control like dropdown list or list box etc with the required initial data, 
        /// </summary>
        private void FillLoadLookUpData()
        {
        }

        /// <summary>
        /// This method is applicable only for Screens with multiple ScreenActionMode, where QuerySting is Involved
        /// </summary>
        private void InitializeScreen()
        {
            //Check if QueryString for ScreenActionMode is supplied, then this Screen is with multiple ScreenActionMode 
            //and the current instance ScreenActionMode is supplied by the QueryString. 
            //In that case we need to overwrite the default ScreenActionMode from ScreenActionMode.UnKnown to the QueryString value.
            if (!string.IsNullOrEmpty(Request.QueryString["ScreenMode"]))
            {
                _CurrentScreenActionMode = (ScreenActionMode)Enum.Parse(typeof(ScreenActionMode), Request.QueryString["ScreenMode"].ToString());
                //Check if the Screen is a single ScreenActionMode 
                if (_CurrentScreenActionMode != ScreenActionMode.UnKnown)
                {
                    //TODO: Logic to Set the screen controls to respective action mode. Example :-
                    //In case of [New] mode the screen should be clear of all existing data.
                    //In case of [Edit] mode the screen should be filled with the existing record that is to be edited.
                    if (_CurrentScreenActionMode == ScreenActionMode.New)
                    {
                        //Check for any other QueryString as per business logic. Example:-
                        //if (!string.IsNullOrEmpty(Request.QueryString["OrganizationKey"]))
                        //{
                        //TODO: business logic.
                        //}
                    }
                    if (_CurrentScreenActionMode == ScreenActionMode.Edit)
                    {
                        //Check for any other QueryString as per business logic. Example:-
                        //if (!string.IsNullOrEmpty(Request.QueryString["OrganizationKey"]))
                        //{
                        //TODO: business logic.
                        //}
                        if (Request.QueryString["UserKey"] != null)
                        {
                            if (Request.QueryString["UserOrganizationKey"] != null)
                            {
                                int UserKey = Convert.ToInt32(Request.QueryString["UserKey"].ToString());
                                int UserOrganizationKey = Convert.ToInt32(Request.QueryString["UserOrganizationKey"].ToString());
                                //also put the userkey and orgkey to view state
                                UserRoleAllocationHeaderReport _UserRoleAllocationSummaryReport;
                                SiteAdministrationBus _SiteAdministrationBus = new SiteAdministrationBus();
                                _UserRoleAllocationSummaryReport = _SiteAdministrationBus.GetAllUserRoleAllocationSummaryReportByUserKeyUserOrganizationKey(UserKey, UserOrganizationKey);
                                TranslateUserRoleAllocationEntityToUIControls(_UserRoleAllocationSummaryReport);
                                ViewState[_TheDefaultValueForUserRoleAllocationSessionVariableName] = _UserRoleAllocationSummaryReport;

                            }
                        }
                    }
                    if (_CurrentScreenActionMode == ScreenActionMode.Display)
                    {
                        //Check for any other QueryString as per business logic. Example:-
                        //if (!string.IsNullOrEmpty(Request.QueryString["OrganizationKey"]))
                        //{
                        //TODO: business logic.
                        //}
                    }
                }
            }
            else
            {
                if (_CurrentScreenActionMode != ScreenActionMode.Display)
                {
                    //Check for any other QueryString as per business logic. Example:-
                    //if (!string.IsNullOrEmpty(Request.QueryString["OrganizationKey"]))
                    //{
                    //TODO: business logic.
                    //}
                }
            }

            ClearScreen();
            FillLoadLookUpData();
            LoadUserRoleAllocationDetailsForThisRole();
            LoadAllUserRoleAllocationDetailsByUserKeyOrganizationKey();
            //TODO: rest of the display logic code
        }

        /// <summary>
        /// This method is to copy the entity properties that need to be displayed in the UI controls to the UI control.
        /// Example - [pUser] is an instance of an entity and is filled with specific USER data.
        /// and this user instance is to be displayed is an UI control text boxes.
        /// A sample code will look like the following:
        ///  this.txtFirstName.Text = pUser.UserFirstName; 
        ///  this.txtLastName.Text  = pUser.UserLastName; 
        ///  this.txtLoginId.Text   = pUser.UserLoginID;
        /// </summary>
        /// 
        private void TranslateUserRoleAllocationEntityToUIControls(UserRoleAllocationHeaderReport pUserRoleAllocationHeaderReport)
        {
            this.lblUserKey.Text = Convert.ToString("[" + pUserRoleAllocationHeaderReport.UserKey) + "]";
            this.lblUserLoginID.Text = "[" + pUserRoleAllocationHeaderReport.UserLoginId + "]";
            this.lblUserOrganizationCode.Text = "[" + pUserRoleAllocationHeaderReport.UserOrganizationCode + "]";
            this.lblUserFullName.Text = "[" + pUserRoleAllocationHeaderReport.PersonFirstName + "  " + pUserRoleAllocationHeaderReport.PersonLastName + "]";
            this.lblEmailId.Text = "[" + pUserRoleAllocationHeaderReport.PersonPrimaryEmailID + "]";
            this.lblUserOrganizationName.Text = "[" + pUserRoleAllocationHeaderReport.UserOrganizationName + "]";
            this.lblDisplayUserName.InnerText = "[" + pUserRoleAllocationHeaderReport.PersonFirstName + "  " + pUserRoleAllocationHeaderReport.PersonLastName + "]";

        }

        /// <summary>
        /// This method is to copy the user entered data from the UI controls to the entity instance that will be used to sent the entity to any other layer.
        /// Example - [pUser] is an instance of an entity and is to be filled with specific USER data that has been captured in the screen.
        /// A sample code will look like the following:
        ///  pUser.UserFirstName = this.txtFirstName.Text; 
        ///  pUser.UserLastName  = this.txtLastName.Text; 
        ///  pUser.UserLoginID   = this.txtLoginId.Text; 
        /// </summary>
        private void TranslateUserRoleAllocationUIControlsToEntity(Sys_RoleMaster pSys_RoleMaster, UserOrganizationRole pUserOrganizationRole, UserRoleAllocationHeaderReport pUserRoleAllocationHeaderReport)
        {
            //pSys_RoleMaster.RoleCode = pUserOrganizationRole.UserRoleCode;
            //pSys_RoleMaster.RoleName = pUserOrganizationRole.UserRoleName;
            pUserOrganizationRole.UserKey = pUserRoleAllocationHeaderReport.UserKey;
            pUserOrganizationRole.UserOrganizationKey = pUserRoleAllocationHeaderReport.UserOrganizationKey;
            pUserOrganizationRole.UserRoleKey = pSys_RoleMaster.RoleKey;
            pUserOrganizationRole.UserLoginID = pUserRoleAllocationHeaderReport.UserLoginId;
            pUserOrganizationRole.UserOrganizationCode = pUserRoleAllocationHeaderReport.UserOrganizationCode;
            pUserOrganizationRole.UserOrganizationName = pUserRoleAllocationHeaderReport.UserOrganizationName;
            pUserOrganizationRole.UserRoleCode = pSys_RoleMaster.RoleCode;
            pUserOrganizationRole.UserRoleName = pSys_RoleMaster.RoleName;
        }

        private void LoadUserRoleAllocationDetailsForThisRole()
        {
            int UserKey = Convert.ToInt32(Request.QueryString["UserKey"].ToString());
            int UserOrganizationKey = Convert.ToInt32(Request.QueryString["UserOrganizationKey"].ToString());
            UserManagementBus _UserManagementBus = new UserManagementBus();
            List<UserOrganizationRoleSummaryReport> _UserOrganizationRoleSummaryReportList;
            _UserOrganizationRoleSummaryReportList = _UserManagementBus.GetByUserKeyUserOrganizationKey(UserKey, UserOrganizationKey);
            if (_UserOrganizationRoleSummaryReportList.Count > 0)
            {
                this.gvRemoveUserRoleAllocationDetails.DataSource = _UserOrganizationRoleSummaryReportList;
                this.gvRemoveUserRoleAllocationDetails.DataBind();
            }
        }

        private void LoadAllUserRoleAllocationDetailsByUserKeyOrganizationKey()
        {
            int UserKey = Convert.ToInt32(Request.QueryString["UserKey"].ToString());
            int UserOrganizationKey = Convert.ToInt32(Request.QueryString["UserOrganizationKey"].ToString());

            UserManagementBus _UserManagementBus = new UserManagementBus();
            List<Sys_RoleMaster> _Sys_RoleMasterList;
            _Sys_RoleMasterList = _UserManagementBus.GetAllSysRoleMasterByUserKeyUserOrganizationKey(UserKey, UserOrganizationKey);
            if (_Sys_RoleMasterList.Count > 0)
            {
                this.gvAddUserRoleAllocationDetails.DataSource = _Sys_RoleMasterList;
                this.gvAddUserRoleAllocationDetails.DataBind();
            }
            else
            {
                this.lblUserRoleAllocationDetailsError.InnerText = "No Records";
                this.btnAddSelectedActivites.Enabled = false;
            }
        }
        #endregion Private Methods
    }
}